import { request,getFullImageUrl,initBaseUrl } from '../../../utils/request';
import { uploadFile,uploadFileToOss } from '@/utils/request';
export default {
    data() {
      return {
        frontImage: '', // 身份证正面图片
        backImage: '', // 身份证反面图片
        defaultImage: getFullImageUrl('/my/zhengmian.png'), // 默认图片路径
        defaultImagefang: getFullImageUrl('/my/fangmian.png'), // 默认图片URL
        name: '', // 姓名
        idType: '', // 证件类型
        idNumber: '', // 身份证号
        isRecognizing: false, // 是否正在识别中
        ocrApiUrl: 'https://your-ocr-api-endpoint.com', // OCR识别API地址
        faceApiUrl: 'https://your-face-api-endpoint.com', // 人脸识别API地址
        idTypeOptions: ['身份证', '护照', '港澳通行证', '台湾通行证', '其他证件'], // 证件类型选项
        idTypeIndex: 0 // 当前选中的证件类型索引
      };
    },
    computed: {
        isFormValid() {
            // 仅检查身份证正反面是否上传
            return this.frontImage && this.frontImage !== this.defaultImage &&
                   this.backImage && this.backImage !== this.defaultImage;
          }
    },
    methods: {
      handleBack() {
        uni.navigateBack();
      },
      
      // 处理证件类型选择变化
      onIdTypeChange(e) {
        const index = e.detail.value;
        this.idTypeIndex = index;
        this.idType = this.idTypeOptions[index];
      },
      
      // 点击证件上传
      handleCardClick(type) {
        if (type === 'front' && (!this.frontImage || this.frontImage === this.defaultImage)) {
          this.uploadCard('front');
        } else if (type === 'back' && (!this.backImage || this.backImage === this.defaultImage)) {
          this.uploadCard('back');
        }
      },
      
      // 重新上传
      handleReupload(type) {
        if (type === 'front') {
          this.frontImage = '';
          this.name = '';
          this.idType = '';
          this.idNumber = '';
        } else {
          this.backImage = '';
        }
        this.uploadCard(type);
      },
      
      // 上传证件并识别
      uploadCard(type) {
        uni.chooseImage({
          count: 1,
          sizeType: ['compressed'],
          sourceType: ['album', 'camera'],
          success: async (res) => {
            const tempFilePath = res.tempFilePaths[0];
            uni.showLoading({
              title: '正在上传图片...'
            });

            try {
              // 先上传文件获取链接
              const uploadResult = await uploadFile({
                url: '/Common/uploadLocalOnly', // 替换为实际的文件上传接口
                filePath: tempFilePath,
                name: 'file',
                formData: {
                  type: type === 'front' ? 'front' : 'back'
                }
              });
              console.log(uploadResult.data);
              // 检查响应数据是否存在
              if (!uploadResult) {
                throw new Error('上传接口返回为空');
              }

              // 尝试解析JSON
              let uploadData;
              try {
                uploadData = JSON.parse(uploadResult);
              } catch (jsonError) {
                console.error('JSON解析错误:', jsonError);
                console.error('原始响应数据:', uploadData.data);
                throw new Error('上传接口返回格式不正确');
              }

              if (uploadData.code !== 1) {
                throw new Error(uploadData.msg || '文件上传失败');
              }

              // 获取文件链接
              const fileUrl = uploadData.data.fullurl;
              if (!fileUrl) {
                throw new Error('未获取到文件链接');
              }

              // 更新图片显示 
              if (type === 'front') {
                this.frontImage = fileUrl;
              } else {
                this.backImage = fileUrl;
              }

              uni.hideLoading();

              // 如果是正面图片，进行OCR识别
              if (type === 'front' && !this.isRecognizing) {
                this.isRecognizing = true;
                uni.showLoading({
                  title: '正在识别证件信息...'
                });

                try {
                  // 传入type参数
                  const ocrResult = await this.recognizeIDCard(fileUrl, type);

                  // 填充识别结果
                  this.name = ocrResult.name || '';
                  this.idType = this.determineIdType(ocrResult.id_number);
                  this.idNumber = ocrResult.id_number || '';

                  uni.hideLoading();
                } catch (error) {
                  console.error('识别失败:', error);
                  uni.hideLoading();
                  uni.showToast({
                    title: '识别失败，请重新上传',
                    icon: 'none'
                  });
                } finally {
                  this.isRecognizing = false;
                }
              }
            } catch (error) {
              console.error('上传失败:', error);
              uni.hideLoading();
              uni.showToast({
                title: error.message || '上传失败，请重新上传',
                icon: 'none'
              });
            }
          }
        });
      },

      // 调用OCR识别API，增加type参数
      async recognizeIDCard(imageUrl, type) {
        return request({
          url: '/User/idCardOcr',
          method: 'POST',
          data: {
            imageUrl: imageUrl,
            side: type === 'front' ? 'front' : 'back'
          }
        }).then(res => {
          if (res.code === 1) {
            return res.data;
          } else {
            throw new Error(res.data.message);
          }
        });
      },
      
      // 根据身份证号判断证件类型
      determineIdType(idNumber) {
        if (!idNumber) return '';
        
        // 简单的身份证号验证
        const idReg = /^[1-9]\d{5}(18|19|20)\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])\d{3}[\dXx]$/;
        
        if (idReg.test(idNumber)) {
          return '身份证';
        } else {
          // 其他证件类型判断逻辑
          return '其他证件';
        }
      },
      
      // 下一步 - 跳转到录像页面
      async handleNext() {
        if (!this.isFormValid) {
          uni.showToast({
            title: '请完成所有信息',
            icon: 'none'
          });
          return;
        }

        try {
          // 跳转到录像页面
          uni.navigateTo({
            url: '/pages/face-capture/face-capture',
            events: {
              // 监听face-capture页面返回的数据
              faceCaptureComplete: async (data) => {
                if (data.success) {
                  await this.handleFaceCaptureComplete(data);
                } else {
                  uni.showToast({
                    title: '录像失败，请重试',
                    icon: 'none'
                  });
                }
              }
            },
            success: (res) => {
              // 通过eventChannel向被打开页面传送数据
              res.eventChannel.emit('acceptDataFromOpenerPage', { 
                from: 'Authn',
                type: 'realNameAuth'
              });
            }
          });
        } catch (error) {
          uni.showToast({
            title: error.message || '操作失败，请重试',
            icon: 'none'
          });
        }
      },

      // 处理录像完成后的逻辑
      async handleFaceCaptureComplete(data) {
        try {
          // 显示上传进度
          uni.showLoading({
            title: '正在处理视频...',
            mask: true  // 防止用户操作
          });

          // 检查视频文件是否存在
          if (!data.videoPath) {
            throw new Error('未获取到视频文件');
          }
          console.log(data.videoPath);
          // 上传视频文件
          const uploadResult = await uploadFile({
            url: '/Common/upload',
            filePath: data.videoPath,
            name: 'file',
            formData: {
              type: 'video'
            }
          });

          // 解析上传结果
          let uploadData;
          try {
            uploadData = JSON.parse(uploadResult);
          } catch (jsonError) {
            console.error('视频上传响应解析错误:', jsonError);
            throw new Error('服务器响应格式错误，请稍后重试');
          }

          if (uploadData.code !== 1) {
            throw new Error(uploadData.msg || '视频上传失败');
          }

          const videoFileUrl = uploadData.data.fullurl;
          if (!videoFileUrl) {
            throw new Error('未获取到视频链接');
          }

          // 提交实名认证信息，包含视频链接
          uni.showLoading({
            title: '正在提交认证...',
            mask: true
          });

          const response = await request({
            url: '/user/realNameAuth',
            method: 'POST',
            data: {
              realname: this.name,
              idcard: this.idNumber,
              idcard_front: this.frontImage,
              idcard_back: this.backImage,
              url: uploadData.data.url,  // 视频链接参数
              fullurl: uploadData.data.fullurl
            }
          });

          uni.hideLoading();

          if (response.code === 1) {
            uni.showToast({
              title: '实名认证提交成功',
              icon: 'success',
              duration: 2000
            });
            
            // 延迟返回，让用户看到成功提示
            setTimeout(() => {
              uni.navigateBack();
            }, 1500);
          } else {
            // 认证失败，显示具体错误信息
            const errorMsg = response.msg || response.message || '认证失败';
            uni.showModal({
              title: '认证失败',
              content: errorMsg,
              showCancel: false,
              confirmText: '知道了'
            });
          }
        } catch (error) {
          uni.hideLoading();
          
          // 根据不同错误类型提供具体提示
          let errorMessage = '操作失败，请重试';
          if (error.message) {
            errorMessage = error.message;
          } else if (error.errMsg) {
            errorMessage = error.errMsg;
          }
          
          // 网络错误或服务器错误
          if (errorMessage.includes('network') || errorMessage.includes('timeout')) {
            errorMessage = '网络连接异常，请检查网络后重试';
          } else if (errorMessage.includes('upload')) {
            errorMessage = '视频上传失败，请检查网络或重新录制';
          }
          
          uni.showModal({
            title: '操作失败',
            content: errorMessage,
            showCancel: false,
            confirmText: '知道了'
          });
        }
      },
      
      // 验证身份证信息
      validateIdInfo() {
        // 这里应该是调用后端API验证身份证信息
        return Promise.resolve(true); // 模拟成功
      },
      
      // 启动人脸识别
      startFaceRecognition() {
        return new Promise((resolve, reject) => {
          // 使用uni-app的人脸识别插件或调用API
          // 这里以使用uni-face-sdk为例
          if (typeof uni.startFaceRecognition === 'function') {
            uni.startFaceRecognition({
              success: (res) => {
                if (res.code === 0) {
                  resolve(res.result);
                } else {
                  reject(new Error(res.message));
                }
              },
              fail: (err) => {
                reject(err);
              }
            });
          } else {
            // 如果没有原生插件，可以使用web方式
            uni.navigateTo({
              url: '/pages/face-recognition/face-recognition',
              events: {
                recognitionSuccess: (data) => {
                  resolve(data);
                },
                recognitionFailed: (err) => {
                  reject(err);
                }
              }
            });
          }
        });
      }
    }
  };
